import java.util.Scanner;

public class Test_7_10 {
//      求最大值方法的重载
//    在同一个类中定义多个方法：要求不仅可以求2个整数的最大值，还可以求3个小数的最大值？

    public static int max(int a,int b) {
        return Math.max(a,b);
    }

    public static double max(double a,double b,double c) {

        double m = Math.max(a,b);
        return Math.max(m,c);
    }

    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        int a = scan.nextInt();
        int b = scan.nextInt();
        System.out.println(max(a, b));

        double i = scan.nextDouble();
        double j = scan.nextDouble();
        double k = scan.nextDouble();
        System.out.println(max(i, j, k));

    }





//    递归求 1 + 2 + 3 + ... + 10

    public static int Sum(int n){
        if(n == 1){
            return 1;
        }
        return n + Sum(n - 1);
    }

    public static void main7(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        System.out.println(Sum(n));
    }



//    求阶乘和

//    求和：
    public static int facSum(int n){
        int sum = 0;
        for(int i = 1;i <= n;i++){
            sum +=fac1(i);
        }
        return sum;
    }

//    求阶乘：
    public static int fac1(int i){
        if(i == 1){
            return 1;
        }
        return i*fac1(i - 1);
    }

    public static void main6(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        System.out.println(facSum(n));
    }

//    递归求 N 的阶乘

    public static int fac(int n){
        if(n == 1){
            return 1;
        }
        return n * fac(n - 1);
    }

    public static void main5(String[] args) {
        Scanner scan = new Scanner(System.in);
        int N = scan.nextInt();
        System.out.println(N + "的阶乘为：" + fac(N));
    }




//    递归求解汉诺塔问题
//    若有 n 个要移动的盘，则需要移动 (2^n)-1次

//    模拟盘移动到柱：
    public static void move(char pos1,char pos2) {
        System.out.print(pos1 + "->" + pos2 + " ");
    }

    /*
    * n 代表盘子的个数
    * pos1：起始位置
    * pos2：中转位置
    * pos3：目标位置
    * */
    public static void hanoi(int n,char pos1,char pos2,char pos3) {
        if(n == 1) {
            move(pos1,pos3);
            return;
        }
        else{
//           1. 此时的中转位置为‘C’，我们需要将 n - 1 个盘子通过‘C’移动到‘B’放着
            hanoi(n-1,pos1,pos3,pos2);
//           2. 然后再将 pos1 的最大盘移到 pos3
            move(pos1,pos3);
//           3. 最后一步，将其余 n - 1 个盘子通过‘A’为中转，移动到目标‘C’
            hanoi(n-1,pos2,pos1,pos3);
        }
    }

    public static void main4(String[] args) {
        hanoi(1,'A','B','C');
        System.out.println();

        hanoi(2,'A','B','C');
        System.out.println();

        hanoi(3,'A','B','C');
        System.out.println();
    }








//    递归求斐波那契数列的第 N 项

    public static int fib(int n){
        if(n == 1 || n == 2){
            return 1;
        }
        return (fib(n - 1) + fib(n - 2));
    }

    public static void main3(String[] args) {
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        System.out.println("第" + n + "项斐波那契数为" + fib(n));
    }





//    写一个递归方法，输入一个非负整数，返回组成它的数字之和

    public static int sum(int num){
        if(num > 9){
            return sum(num / 10) + num % 10;
        }
        return num;
    }

    public static void main2(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        System.out.println(sum(num));
    }









//      按顺序打印一个数字的每一位(例如 1234 打印出 1 2 3 4)    （递归)

    public static void print(int num){
        if(num > 9){
            print(num / 10);
        }
        System.out.print(num % 10 + " ");
    }

    public static void main1(String[] args) {
        Scanner scan = new Scanner(System.in);
        int num = scan.nextInt();
        print(num);
    }

}
